// diagnosis.js
const app = getApp();
const api = require('../../utils/api.js');
const debugTools = require('../../utils/debugTools.js'); // 调试工具引入库
import { parseMd } from '../../utils/mdparser'; // 导入Markdown解析函数

Page({
  data: {
    image: '',
    imagePath: '',
    result: null,
    loading: false,
    error: '',
    showFullContent: false,
    historyRecords: [],
    showHistory: false,
    processingStatus: '',
    currentTaskId: null,
    markdownDiagnosis: null,
    markdownTreatment: null,
    markdownPrevention: null,
    markdownFullContent: null
  },

  onLoad() {
    // 页面加载时执行的操作
  },

  // 打开相机
  openCamera() {
    this.chooseImage(['camera']);
  },

  // 打开相册
  openAlbum() {
    this.chooseImage(['album']);
  },

  // 选择图片的通用方法
  chooseImage(sourceType = ['album', 'camera']) {
    const that = this;
    wx.chooseImage({
      count: 1,
      sizeType: ['compressed'],
      sourceType: sourceType,
      success(res) {
        // 获取图片临时路径
        const tempFilePath = res.tempFilePaths[0];
        
        that.setData({
          imagePath: tempFilePath,
          image: tempFilePath,
          result: null,
          error: ''
        });
      }
    });
  },

  // 上传图片进行识别
  identifyPlant() {
    if (!this.data.imagePath) {
      this.setData({
        error: '请先选择或拍摄一张图片'
      });
      return;
    }

    this.setData({ 
      loading: true,
      error: '' 
    });

    const that = this;

    // 修改为先读取图片数据为base64再发送
    wx.getFileSystemManager().readFile({
      filePath: this.data.imagePath,
      encoding: 'base64',
      success(res) {
        console.log('成功读取图片，准备发送API请求');
        
        // 使用调试工具检查图片数据
        const debugInfo = debugTools.showImageDebugInfo(res.data);
        console.log('图片数据检查结果:', debugInfo);
        
        // 根据检查结果决定是否继续
        if (!debugInfo.isValid) {
          console.error('图片数据无效:', debugInfo.message);
          that.setData({
            loading: false,
            error: '图片数据格式无效: ' + debugInfo.message
          });
          return;
        }
        
        console.log(`图片数据有效，长度: ${debugInfo.length}`);

        // 直接使用原始图片数据，移除压缩步骤
        const base64Data = res.data;
        
        // 优先调用豆包识别 (移除阿里云识别调用)
        that.callDoubaoIdentifyAPI(base64Data);
      },
      fail(err) {
        console.error('读取图片失败:', err);
        that.setData({
          loading: false,
          error: '读取图片失败: ' + err.errMsg
        });
      }
    });
  },

  // 压缩图片 - 暂不实现，直接返回原始数据
  compressImage(base64Data) {
    console.log('TODO: 实现图片压缩算法');
    // 直接返回原始数据，不进行压缩
    return base64Data;
  },
  
  // 调用豆包识别植物API
  callDoubaoIdentifyAPI(base64Data) {
    const that = this;
    
    this.setData({
      processingStatus: '正在识别植物种类...'
    });
    
    // 使用封装的API函数而不是直接调用端点
    api.identifyPlantWithDoubao(base64Data)
      .then(data => {
        that.setData({
          processingStatus: '植物识别完成'
        });
        
        if (data.success && data.result) {
          const plantInfo = {
            cname: data.result.name,
            latin: data.result.latin || '',
            family: data.result.family || '',
            score: data.result.score || 0.8,
            features: data.result.features || '',
            identifiedBy: '豆包AI', // 标记识别来源
            responseTime: data.result.responseTime || 0 // 添加响应时间
          };
          
          console.log(`豆包识别植物响应时间: ${plantInfo.responseTime}ms`);
          console.log('豆包识别出的植物信息:', JSON.stringify(plantInfo, null, 2));
          
          // 获取病害信息
          that.getDiseaseInfo(plantInfo);
        } else {
          that.setData({
            loading: false,
            error: '无法识别该图片中的植物，请尝试更清晰的图片'
          });
        }
      })
      .catch(err => {
        that.setData({
          processingStatus: ''
        });
        
        console.error('豆包植物识别API错误:', err);
        
        // 检查是否是404错误（API不存在）
        if (err.message && (err.message.includes('404') || err.message.includes('不存在'))) {
          that.setData({
            loading: false,
            error: '豆包植物识别API未部署或配置错误 (404)，请联系管理员',
            processingStatus: ''
          });
        } else {
          that.setData({
            loading: false,
            error: '识别失败: ' + (err.message || '未知错误')
          });
        }
      });
  },

  // 获取病害信息，整合AI诊断
  getDiseaseInfo(plantInfo) {
    const that = this;
    
    console.log('获取病害信息,植物名称:', plantInfo.cname);
    
    // 获取用户所在地区信息（可以从全局配置或用户设置中获取）
    const userRegion = app.globalData.userRegion || '中国';
    
    // 设置加载状态
    this.setData({ 
      loading: true,
      processingStatus: '正在进行AI诊断...' 
    });
    
    // 保存图片数据用于AI分析
    wx.getFileSystemManager().readFile({
      filePath: this.data.imagePath,
      encoding: 'base64',
      success(res) {
        // 确保base64Data是字符串
        const base64Data = res.data;
        
        // 使用调试工具检查图片数据
        const debugInfo = debugTools.showImageDebugInfo(base64Data);
        console.log('图片数据检查结果:', debugInfo);
        
        if (!debugInfo.isValid) {
          that.setData({
            loading: false,
            error: '图片数据格式无效: ' + debugInfo.type
          });
          return;
        }
        
        console.log(`图片数据已获取，类型: ${typeof base64Data}, 长度: ${base64Data.length}`);
        
        // 根据豆包API要求正确格式化图片数据
        let imageFormat = 'jpeg'; // 默认JPEG格式
        if (that.data.imagePath.endsWith('.png')) {
          imageFormat = 'png';
        } else if (that.data.imagePath.endsWith('.webp')) {
          imageFormat = 'webp';
        }
        
        // 按照豆包API要求构建完整的图像URL格式
        const formattedImageData = `data:image/${imageFormat};base64,${base64Data}`;
        console.log('已格式化图片数据，添加前缀:', `data:image/${imageFormat};base64,`);
        
        // 直接调用AI诊断API，同时传递植物识别结果
        api.getAiDiagnosis(plantInfo.cname, formattedImageData, userRegion, '', plantInfo)
          .then(aiResult => {
            if (aiResult.success && aiResult.result) {
              // 将Markdown转换为富文本节点
              const markdownDiagnosis = parseMd(aiResult.result.aiDiagnosis || '');
              const markdownTreatment = parseMd(aiResult.result.treatment || '');
              const markdownPrevention = parseMd(aiResult.result.preventionTips || '');
              const markdownFullContent = parseMd(aiResult.result.fullContent || '');
              
              that.setData({
                loading: false,
                processingStatus: '',
                result: {
                  plantName: plantInfo.cname,
                  latinName: plantInfo.latin || '',
                  family: plantInfo.family || '',
                  confidence: (parseFloat(plantInfo.score) * 100).toFixed(1) + '%',
                  treatment: aiResult.result.treatment || '暂无治疗方案',
                  aiDiagnosis: aiResult.result.aiDiagnosis || '',
                  preventionTips: aiResult.result.preventionTips || '',
                  growthAdvice: aiResult.result.growthAdvice || '',
                  fullContent: aiResult.result.fullContent || '',
                },
                markdownDiagnosis,
                markdownTreatment,
                markdownPrevention,
                markdownFullContent
              });
              
              // 记录响应时间
              console.log(`AI诊断响应时间: ${aiResult.result.responseTime}ms`);
              
              // 记录诊断历史
              that.saveDiagnosisHistory({
                plantName: plantInfo.cname,
                imageUrl: that.data.imagePath,
                diagnosisTime: new Date(),
                diagnosisResult: aiResult.result.aiDiagnosis
              });
            } else {
              // AI诊断失败，回退到传统方法
              console.warn('AI诊断返回异常，回退到传统方法');
              that.setData({
                processingStatus: '' // 清除处理状态提示
              });
              that.getTraditionalDiseaseInfo(plantInfo);
            }
          })
          .catch(err => {
            console.error('AI诊断失败:', err);
            // 出错时回退到传统方法
            that.setData({
              processingStatus: '' // 清除处理状态提示
            });
            that.getTraditionalDiseaseInfo(plantInfo);
          });
      },
      fail(err) {
        console.error('读取图片失败:', err);
        // 读取失败时回退到传统方法
        that.setData({
          processingStatus: '' // 清除处理状态提示
        });
        that.getTraditionalDiseaseInfo(plantInfo);
      }
    });
  },

  // 保存诊断历史记录
  saveDiagnosisHistory(diagnosisRecord) {
    try {
      // 获取现有历史记录
      const historyRecords = wx.getStorageSync('diagnosisHistory') || [];
      
      // 添加新记录到开头
      historyRecords.unshift(diagnosisRecord);
      
      // 限制记录数量，最多保存10条
      const limitedRecords = historyRecords.slice(0, 10);
      
      // 存储回本地
      wx.setStorageSync('diagnosisHistory', limitedRecords);
      
      // 如果用户已登录，保存到服务器数据库
      const userInfo = app.globalData.userInfo || wx.getStorageSync('userInfo');
      if (userInfo && userInfo.userId) {
        console.log('用户已登录，保存诊断记录到服务器');
        
        // 在当前诊断结果的基础上补充更完整的信息
        const fullDiagnosisRecord = {
          plantName: this.data.result.plantName,
          latinName: this.data.result.latinName || '',
          family: this.data.result.family || '',
          imageUrl: this.data.imagePath || '',  // 本地图片路径，后端需要处理上传
          diagnosisResult: this.data.result.aiDiagnosis || '',
          treatment: this.data.result.treatment || '',
          preventionTips: this.data.result.preventionTips || '',
          growthAdvice: this.data.result.growthAdvice || ''
        };
        
        // 调用服务端保存API
        wx.request({
          url: api.apiEndpoints.saveDiagnosisHistoryUrl(),
          method: 'POST',
          data: {
            userId: userInfo.userId,
            diagnosisRecord: fullDiagnosisRecord
          },
          success: (res) => {
            if (res.data.success) {
              console.log('诊断记录已保存到服务器', res.data);
            } else {
              console.warn('保存诊断记录到服务器失败:', res.data.message);
            }
          },
          fail: (err) => {
            console.error('保存诊断记录请求失败:', err);
          }
        });
      } else {
        console.log('用户未登录，诊断记录仅保存在本地');
      }
    } catch (e) {
      console.error('保存诊断历史失败:', e);
    }
  },
  
  // 传统的病害信息获取方法
  getTraditionalDiseaseInfo(plantInfo) {
    const that = this;
    
    // 调用本地服务器API获取植物病害信息
    wx.request({
      url: api.localDiseaseInfo,
      method: 'GET',
      data: {
        plantName: plantInfo.cname
      },
      success(res) {
        console.log('本地API响应:', res.data);
        if (res.statusCode === 200 && res.data.success) {
          that.setData({
            loading: false,
            processingStatus: '', // 清除处理状态提示
            result: {
              plantName: plantInfo.cname,
              latinName: plantInfo.latin || '',
              family: plantInfo.family || '',
              confidence: (parseFloat(plantInfo.score) * 100).toFixed(1) + '%',
              treatment: res.data.treatment || '暂无该植物的病害信息'
            }
          });
          console.log('设置诊断结果完成:', that.data.result);
        } else {
          console.warn('本地API返回错误:', res);
          that.setData({
            loading: false,
            processingStatus: '', // 清除处理状态提示
            result: {
              plantName: plantInfo.cname,
              latinName: plantInfo.latin || '',
              family: plantInfo.family || '',
              confidence: (parseFloat(plantInfo.score) * 100).toFixed(1) + '%',
              treatment: '获取病害信息失败：' + (res.data.message || '未知错误')
            }
          });
        }
      },
      fail(err) {
        console.error('本地API请求失败:', err);
        that.setData({
          loading: false,
          processingStatus: '', // 清除处理状态提示
          result: {
            plantName: plantInfo.cname,
            latinName: plantInfo.latin || '',
            family: plantInfo.family || '',
            confidence: (parseFloat(plantInfo.score) * 100).toFixed(1) + '%',
            treatment: '获取病害信息失败：网络错误，请确保本地服务器已启动。'
          }
        });
      }
    });
  },
  
  // 添加切换完整内容显示的方法
  toggleFullContent() {
    this.setData({
      showFullContent: !this.data.showFullContent
    });
  },
  
  // 添加复制全文的方法
  copyFullContent() {
    if (!this.data.result || !this.data.result.fullContent) {
      wx.showToast({
        title: '无内容可复制',
        icon: 'none'
      });
      return;
    }
    
    wx.setClipboardData({
      data: this.data.result.fullContent,
      success: () => {
        wx.showToast({
          title: '已复制到剪贴板',
          icon: 'success'
        });
      },
      fail: () => {
        wx.showToast({
          title: '复制失败',
          icon: 'none'
        });
      }
    });
  },
  
  // 保存诊断结果到本地
  saveResult() {
    if (!this.data.result) {
      wx.showToast({
        title: '无结果可保存',
        icon: 'none'
      });
      return;
    }
    
    // 构建诊断报告文本
    let report = `植物诊断报告\n\n`;
    report += `植物名称：${this.data.result.plantName}\n`;
    report += `诊断时间：${new Date().toLocaleString()}\n\n`;
    
    if (this.data.result.aiDiagnosis) {
      report += `AI诊断：\n${this.data.result.aiDiagnosis}\n\n`;
    }
    
    if (this.data.result.treatment) {
      report += `防治建议：\n${this.data.result.treatment}\n\n`;
    }
    
    if (this.data.result.preventionTips) {
      report += `预防措施：\n${this.data.result.preventionTips}\n\n`;
    }
    
    if (this.data.result.growthAdvice) {
      report += `种植建议：\n${this.data.result.growthAdvice}\n\n`;
    }
    
    // 使用文件系统API保存文本
    wx.getFileSystemManager().writeFile({
      filePath: `${wx.env.USER_DATA_PATH}/诊断报告_${this.data.result.plantName}_${new Date().getTime()}.txt`,
      data: report,
      encoding: 'utf8',
      success: (res) => {
        console.log("保存成功:", res);
        wx.showToast({
          title: '报告已保存',
          icon: 'success'
        });
      },
      fail: (err) => {
        console.error("保存失败:", err);
        wx.showToast({
          title: '保存失败',
          icon: 'none'
        });
      }
    });
  },
  
  // 分享诊断结果
  onShareAppMessage() {
    const that = this;
    if (this.data.result) {
      return {
        title: `${that.data.result.plantName}的植物诊断结果`,
        path: '/pages/diagnosis/diagnosis',
        imageUrl: that.data.imagePath // 使用诊断的植物图片
      }
    }
    return {
      title: 'NongHi植物诊断助手',
      path: '/pages/index/index'
    }
  },
  
  // 显示诊断历史记录
  showDiagnosisHistory() {
    const historyRecords = wx.getStorageSync('diagnosisHistory') || [];
    if (historyRecords.length === 0) {
      wx.showToast({
        title: '暂无诊断历史',
        icon: 'none'
      });
      return;
    }
    
    // 格式化历史记录以便显示
    const formattedRecords = historyRecords.map(record => {
      return {
        ...record,
        diagnosisTime: new Date(record.diagnosisTime).toLocaleString()
      };
    });
    
    this.setData({
      historyRecords: formattedRecords,
      showHistory: true
    });
  },
  
  // 关闭历史记录
  hideHistory() {
    this.setData({
      showHistory: false
    });
  },
  
  // 查看历史记录中的诊断
  viewHistoryDiagnosis(e) {
    const index = e.currentTarget.dataset.index;
    const record = this.data.historyRecords[index];
    
    // 可以实现在当前页面加载历史诊断或跳转到详情页
    // 这里简单实现为弹窗显示
    wx.showModal({
      title: `${record.plantName}的诊断`,
      content: record.diagnosisResult || '无详细诊断信息',
      showCancel: false
    });
  },
  
  // 诊断植物
  diagnose() {
    // 创建一个计时器
    const timer = new debugTools.PerformanceTimer('植物诊断');
    
    // 第一步：读取图片
    this.readImage()
      .then(imageData => {
        timer.mark('读取图片完成'); // 记录时间点
        return this.identifyPlant(imageData);
      })
      .then(plantInfo => {
        timer.mark('植物识别完成'); // 记录时间点
        return this.getDiseaseDiagnosis(plantInfo, this.data.imageData);
      })
      .then(diagnosisResult => {
        timer.mark('疾病诊断完成'); // 记录时间点
        this.processResult(diagnosisResult);
        
        // 获取整个过程的计时信息
        const timingInfo = timer.end();
        console.log('诊断性能数据:', timingInfo);
        
        // 可以将性能数据上报或展示给用户
        if (timingInfo.total > 5000) {
          console.warn('诊断耗时较长，可能需要优化');
        }
      })
      .catch(error => {
        timer.mark('发生错误');
        console.error('诊断过程出错:', error);
        timer.end();
      });
  }
});
